పైథాన్ ఇటరేషన్ శక్తిని అన్‌లాక్ చేయండి. __iter__ మరియు __next__ పద్ధతులను ఉపయోగించి కస్టమ్ ఇటరేటర్‌లను అమలు చేయడానికి ప్రపంచ డెవలపర్‌ల కోసం సమగ్ర గైడ్, ఆచరణాత్మక ఉదాహరణలతో.
పైథాన్ యొక్క ఇటరేటర్ ప్రోటోకాల్‌ను అర్థం చేసుకోవడం: __iter__ మరియు __next__ లపై లోతైన విశ్లేషణ
ప్రోగ్రామింగ్‌లో ఇటరేషన్ అత్యంత ప్రాథమిక భావనలలో ఒకటి. పైథాన్‌లో, ఇది సాధారణ for లూప్‌ల నుండి సంక్లిష్ట డేటా ప్రాసెసింగ్ పైప్‌లైన్‌ల వరకు ప్రతిదానికీ శక్తినిచ్చే సొగసైన మరియు సమర్థవంతమైన యంత్రాంగం. మీరు జాబితా ద్వారా లూప్ చేసినప్పుడు, ఫైల్ నుండి పంక్తులను చదివినప్పుడు లేదా డేటాబేస్ ఫలితాలతో పని చేస్తున్నప్పుడు ప్రతిరోజూ దీనిని ఉపయోగిస్తారు. అయితే తెర వెనుక ఏమి జరుగుతుందో మీరు ఎప్పుడైనా ఆలోచించారా? అనేక రకాల వస్తువుల నుండి 'తదుపరి' అంశాన్ని ఎలా పొందాలనేది పైథాన్‌కు ఎలా తెలుస్తుంది?
సమాధానం ఇటరేటర్ ప్రోటోకాల్ అని పిలువబడే శక్తివంతమైన మరియు సొగసైన డిజైన్ నమూనాలో ఉంది. ఈ ప్రోటోకాల్ పైథాన్ యొక్క అన్ని సీక్వెన్స్-వంటి వస్తువులు మాట్లాడే సాధారణ భాష. ఈ ప్రోటోకాల్‌ను అర్థం చేసుకోవడం మరియు అమలు చేయడం ద్వారా, మీరు పైథాన్ యొక్క ఇటరేషన్ సాధనాలతో పూర్తిగా అనుకూలంగా ఉండే మీ స్వంత అనుకూల వస్తువులను సృష్టించవచ్చు, మీ కోడ్‌ను మరింత వ్యక్తీకరణగా, మెమరీ-సమర్థవంతంగా మరియు ప్రాథమికంగా 'పైథానిక్' గా చేయవచ్చు.
ఈ సమగ్ర గైడ్ ఇటరేటర్ ప్రోటోకాల్‌లోకి లోతైన విశ్లేషణను అందిస్తుంది. మేము `__iter__` మరియు `__next__` పద్ధతుల వెనుక ఉన్న మాయాజాలాన్ని విప్పుతాము, ఇటరేబుల్ మరియు ఇటరేటర్ మధ్య కీలక వ్యత్యాసాన్ని స్పష్టం చేస్తాము మరియు మీ స్వంత అనుకూల ఇటరేటర్‌లను మొదటి నుండి నిర్మించడంలో మీకు సహాయపడతాము. మీరు పైథాన్ అంతర్గత భాగాలపై మీ అవగాహనను పెంపొందించుకోవాలనుకునే ఇంటర్మీడియట్ డెవలపర్ అయినా లేదా మరింత అధునాతన APIలను రూపొందించాలని లక్ష్యంగా పెట్టుకున్న నిపుణుడు అయినా, ఇటరేటర్ ప్రోటోకాల్‌ను సాధించడం మీ ప్రయాణంలో ఒక కీలకమైన అడుగు.
'ఎందుకు': ఇటరేషన్ యొక్క ప్రాముఖ్యత మరియు శక్తి
మేము సాంకేతిక అమలులోకి ప్రవేశించే ముందు, ఇటరేటర్ ప్రోటోకాల్ ఎందుకు చాలా ముఖ్యమైనదో గుర్తించడం అవసరం. దీని ప్రయోజనాలు కేవలం `for` లూప్‌లను ప్రారంభించడానికే మించిపోతాయి.
మెమరీ సామర్థ్యం మరియు లేజీ ఎవాల్యుయేషన్
మీరు అనేక గిగాబైట్‌ల పరిమాణంలో ఉన్న భారీ లాగ్ ఫైల్‌ను ప్రాసెస్ చేయాలని ఊహించుకోండి. మీరు మొత్తం ఫైల్‌ను మెమరీలోని జాబితాలోకి చదివినట్లయితే, మీరు మీ సిస్టమ్ వనరులను క్షీణింపజేసే అవకాశం ఉంది. ఇటరేటర్‌లు లేజీ ఎవాల్యుయేషన్ అనే భావన ద్వారా ఈ సమస్యను అద్భుతంగా పరిష్కరిస్తాయి.
ఒక ఇటరేటర్ అన్ని డేటాను ఒకేసారి లోడ్ చేయదు. బదులుగా, ఇది అభ్యర్థించినప్పుడు మాత్రమే ఒకేసారి ఒక అంశాన్ని ఉత్పత్తి చేస్తుంది లేదా పొందుతుంది. ఇది క్రమంలో ఎక్కడ ఉందో గుర్తుంచుకోవడానికి అంతర్గత స్థితిని నిర్వహిస్తుంది. దీని అర్థం మీరు అనంతమైన పెద్ద డేటా స్ట్రీమ్‌ను (సిద్ధాంతపరంగా) చాలా తక్కువ, స్థిరమైన మొత్తంలో మెమరీతో ప్రాసెస్ చేయవచ్చు. ఇది మీ ప్రోగ్రామ్‌ను క్రాష్ చేయకుండా భారీ ఫైల్‌ను లైన్-బై-లైన్ చదవడానికి మిమ్మల్ని అనుమతించే అదే సూత్రం.
క్లీన్, రీడబుల్ మరియు యూనివర్సల్ కోడ్
ఇటరేటర్ ప్రోటోకాల్ సీక్వెన్షియల్ యాక్సెస్ కోసం సార్వత్రిక ఇంటర్‌ఫేస్‌ను అందిస్తుంది. జాబితాలు, ట్యూపుల్స్, డిక్షనరీలు, స్ట్రింగ్‌లు, ఫైల్ ఆబ్జెక్ట్‌లు మరియు అనేక ఇతర రకాలు ఈ ప్రోటోకాల్‌కు కట్టుబడి ఉంటాయి కాబట్టి, మీరు వాటి అన్నింటితో పని చేయడానికి అదే సింటాక్స్‌ను — `for` లూప్‌ను ఉపయోగించవచ్చు. ఈ ఏకరూపత పైథాన్ యొక్క రీడబిలిటీకి మూలస్తంభం.
ఈ కోడ్‌ను పరిగణించండి:
కోడ్:
my_list = [1, 2, 3]
for item in my_list:
print(item)
my_string = "abc"
for char in my_string:
print(char)
with open('my_file.txt', 'r') as f:
for line in f:
print(line)
The `for` లూప్ అది పూర్ణాంకాల జాబితాలో, అక్షరాల స్ట్రింగ్‌లో లేదా ఫైల్ నుండి పంక్తులలో ఇటరేట్ చేస్తుందో లేదో పట్టించుకోదు. ఇది కేవలం దాని ఇటరేటర్ కోసం ఆబ్జెక్ట్‌ను అడుగుతుంది మరియు తరువాత ఇటరేటర్ యొక్క తదుపరి అంశం కోసం పదేపదే అడుగుతుంది. ఈ సంగ్రహణ చాలా శక్తివంతమైనది.
ఇటరేటర్ ప్రోటోకాల్‌ను విడదీయడం
ప్రోటోకాల్ స్వయంగా ఆశ్చర్యకరంగా సరళమైనది, కేవలం రెండు ప్రత్యేక పద్ధతుల ద్వారా నిర్వచించబడింది, వీటిని తరచుగా "డండర్" (డబుల్ అండర్‌స్కోర్) పద్ధతులు అని పిలుస్తారు:
- `__iter__()`
- `__next__()`
వీటిని పూర్తిగా అర్థం చేసుకోవడానికి, మనం ముందుగా రెండు సంబంధిత కానీ విభిన్న భావనల మధ్య వ్యత్యాసాన్ని అర్థం చేసుకోవాలి: ఒక ఇటరేబుల్ మరియు ఒక ఇటరేటర్.
ఇటరేబుల్ vs. ఇటరేటర్: ఒక కీలక వ్యత్యాసం
ఇది తరచుగా కొత్త వారికి గందరగోళానికి దారితీస్తుంది, అయితే వ్యత్యాసం చాలా కీలకం.
ఇటరేబుల్ అంటే ఏమిటి?
ఒక ఇటరేబుల్ అనేది లూప్ చేయబడే ఏదైనా ఆబ్జెక్ట్. ఇది ఇటరేటర్‌ను పొందడానికి మీరు అంతర్నిర్మిత `iter()` ఫంక్షన్‌కు పంపగల ఆబ్జెక్ట్. సాంకేతికంగా, ఒక ఆబ్జెక్ట్ `__iter__` పద్ధతిని అమలు చేస్తే అది ఇటరేబుల్‌గా పరిగణించబడుతుంది. దాని `__iter__` పద్ధతి యొక్క ఏకైక ఉద్దేశ్యం ఇటరేటర్ ఆబ్జెక్ట్‌ను తిరిగి ఇవ్వడం.
అంతర్నిర్మిత ఇటరేబుల్‌లకు ఉదాహరణలు:
- జాబితాలు (`[1, 2, 3]`)
- ట్యూపుల్స్ (`(1, 2, 3)`)
- స్ట్రింగ్‌లు (`"hello"`)
- డిక్షనరీలు (`{'a': 1, 'b': 2}` - కీలుపై ఇటరేట్ చేస్తుంది)
- సెట్‌లు (`{1, 2, 3}`)
- ఫైల్ ఆబ్జెక్ట్‌లు
మీరు ఒక ఇటరేబుల్‌ను ఒక కంటైనర్‌గా లేదా డేటా మూలంగా భావించవచ్చు. ఇది అంశాలను స్వయంగా ఎలా ఉత్పత్తి చేయాలో తెలియదు, కానీ అది చేయగలిగే ఒక ఆబ్జెక్ట్‌ను ఎలా సృష్టించాలో తెలుసు: ఇటరేటర్.
ఇటరేటర్ అంటే ఏమిటి?
ఒక ఇటరేటర్ అనేది ఇటరేషన్ సమయంలో వాస్తవంగా విలువలను ఉత్పత్తి చేసే పనిని చేసే ఆబ్జెక్ట్. ఇది డేటా స్ట్రీమ్‌ను సూచిస్తుంది. ఒక ఇటరేటర్ రెండు పద్ధతులను అమలు చేయాలి:
- `__iter__()`: ఈ పద్ధతి ఇటరేటర్ ఆబ్జెక్ట్‌ను స్వయంగా (`self`) తిరిగి ఇవ్వాలి. ఇది అవసరం ఎందుకంటే ఇటరేటర్‌లను `for` లూప్‌లో ఇటరేబుల్స్ ఆశించిన చోట కూడా ఉపయోగించవచ్చు.
- `__next__()`: ఈ పద్ధతి ఇటరేటర్ యొక్క ఇంజిన్. ఇది క్రమంలో తదుపరి అంశాన్ని తిరిగి ఇస్తుంది. తిరిగి ఇవ్వడానికి మరిన్ని అంశాలు లేనప్పుడు, అది ఖచ్చితంగా `StopIteration` మినహాయింపును పెంచాలి. ఈ మినహాయింపు ఒక లోపం కాదు; ఇది ఇటరేషన్ పూర్తయిందని లూపింగ్ నిర్మాణంకు ప్రామాణిక సంకేతం.
ఇటరేటర్ యొక్క ముఖ్య లక్షణాలు:
- ఇది స్థితిని నిర్వహిస్తుంది: ఒక ఇటరేటర్ క్రమంలో దాని ప్రస్తుత స్థానాన్ని గుర్తుంచుకుంటుంది.
- ఇది ఒకేసారి విలువలను ఉత్పత్తి చేస్తుంది: `__next__` పద్ధతి ద్వారా.
- ఇది క్షీణించగలదు: ఒకసారి ఒక ఇటరేటర్ పూర్తిగా వినియోగించబడిన తర్వాత (అంటే, అది `StopIteration` ను పెంచిన తర్వాత), అది ఖాళీగా ఉంటుంది. మీరు దానిని రీసెట్ చేయలేరు లేదా తిరిగి ఉపయోగించలేరు. మళ్ళీ ఇటరేట్ చేయడానికి, మీరు అసలు ఇటరేబుల్‌కు తిరిగి వెళ్లి, `iter()` ను దానిపై మళ్ళీ కాల్ చేయడం ద్వారా కొత్త ఇటరేటర్‌ను పొందాలి.
మా మొదటి కస్టమ్ ఇటరేటర్‌ను నిర్మించడం: ఒక దశల వారీ గైడ్
సిద్ధాంతం గొప్పది, కానీ ప్రోటోకాల్‌ను అర్థం చేసుకోవడానికి ఉత్తమ మార్గం దానిని మీరే నిర్మించడం. ప్రారంభ సంఖ్య నుండి పరిమితి వరకు ఇటరేట్ చేసే ఒక సాధారణ తరగతిని కౌంటర్‌గా పనిచేయడానికి సృష్టిద్దాం.
ఉదాహరణ 1: ఒక సాధారణ కౌంటర్ తరగతి
మేము `CountUpTo` అని పిలువబడే ఒక తరగతిని సృష్టిస్తాము. మీరు దాని యొక్క ఒక ఉదాహరణను సృష్టించినప్పుడు, మీరు గరిష్ట సంఖ్యను పేర్కొంటారు మరియు మీరు దానిపై ఇటరేట్ చేసినప్పుడు, అది 1 నుండి ఆ గరిష్ట సంఖ్య వరకు సంఖ్యలను ఇస్తుంది.
కోడ్:
class CountUpTo:
"""An iterator that counts from 1 up to a specified maximum number."""
def __init__(self, max_num):
print("Initializing the CountUpTo object...")
self.max_num = max_num
self.current = 0 # This will store the state
def __iter__(self):
print("__iter__ called, returning self...")
# This object is its own iterator, so we return self
return self
def __next__(self):
print("__next__ called...")
if self.current < self.max_num:
self.current += 1
return self.current
else:
# This is the crucial part: signal that we are done.
print("Raising StopIteration.")
raise StopIteration
# How to use it
print("Creating the counter object...")
counter = CountUpTo(3)
print("\nStarting the for loop...")
for number in counter:
print(f"For loop received: {number}")
కోడ్ బ్రేక్‌డౌన్ మరియు వివరణ
`for` లూప్ నడుస్తున్నప్పుడు ఏమి జరుగుతుందో విశ్లేషిద్దాం:
- ప్రారంభించడం: `counter = CountUpTo(3)` మా తరగతి యొక్క ఒక ఉదాహరణను సృష్టిస్తుంది. `__init__` పద్ధతి నడుస్తుంది, `self.max_num` ను 3కి మరియు `self.current` ను 0కి సెట్ చేస్తుంది. మా ఆబ్జెక్ట్ యొక్క స్థితి ఇప్పుడు ప్రారంభించబడింది.
- లూప్‌ను ప్రారంభించడం: `for number in counter:` పంక్తికి చేరుకున్నప్పుడు, పైథాన్ అంతర్గతంగా `iter(counter)` ను పిలుస్తుంది.
- `__iter__` కు కాల్ చేయబడింది: `iter(counter)` కాల్ మా `counter.__iter__()` పద్ధతిని ఆహ్వానిస్తుంది. మా కోడ్ నుండి మీరు చూడగలిగినట్లుగా, ఈ పద్ధతి కేవలం ఒక సందేశాన్ని ముద్రించి `self` ను తిరిగి ఇస్తుంది. ఇది `for` లూప్‌కు "మీరు `__next__` ను పిలవాల్సిన ఆబ్జెక్ట్ నేను!" అని చెబుతుంది.
- లూప్ ప్రారంభమవుతుంది: ఇప్పుడు `for` లూప్ సిద్ధంగా ఉంది. ప్రతి ఇటరేషన్‌లో, అది అందుకున్న ఇటరేటర్ ఆబ్జెక్ట్‌పై (అది మా `counter` ఆబ్జెక్ట్) `next()` ను పిలుస్తుంది.
- మొదటి `__next__` కాల్: `counter.__next__()` పద్ధతికి కాల్ చేయబడింది. `self.current` 0, ఇది `self.max_num` (3) కంటే తక్కువ. కోడ్ `self.current` ను 1కి పెంచుతుంది మరియు దానిని తిరిగి ఇస్తుంది. `for` లూప్ ఈ విలువను `number` వేరియబుల్‌కు కేటాయిస్తుంది మరియు లూప్ బాడీ (`print(...)`) అమలు చేస్తుంది.
- రెండవ `__next__` కాల్: లూప్ కొనసాగుతుంది. `__next__` మళ్ళీ కాల్ చేయబడుతుంది. `self.current` 1. ఇది 2కి పెంచబడుతుంది మరియు తిరిగి ఇవ్వబడుతుంది.
- మూడవ `__next__` కాల్: `__next__` మళ్ళీ కాల్ చేయబడుతుంది. `self.current` 2. ఇది 3కి పెంచబడుతుంది మరియు తిరిగి ఇవ్వబడుతుంది.
- చివరి `__next__` కాల్: `__next__` మరోసారి కాల్ చేయబడుతుంది. ఇప్పుడు, `self.current` 3. `self.current < self.max_num` అనే షరతు తప్పు. `else` బ్లాక్ అమలు చేయబడుతుంది మరియు `StopIteration` పెంచబడుతుంది.
- లూప్‌ను ముగించడం: `for` లూప్ `StopIteration` మినహాయింపును పట్టుకోవడానికి రూపొందించబడింది. అది చేసినప్పుడు, ఇటరేషన్ పూర్తయిందని దానికి తెలుసు మరియు సజావుగా ముగుస్తుంది. లూప్ తర్వాత ఏదైనా కోడ్‌ను ప్రోగ్రామ్ అమలు చేయడం కొనసాగిస్తుంది.
ఒక కీలక వివరాలను గమనించండి: మీరు అదే `counter` ఆబ్జెక్ట్‌పై `for` లూప్‌ను మళ్ళీ అమలు చేయడానికి ప్రయత్నిస్తే, అది పనిచేయదు. ఇటరేటర్ అయిపోయింది. `self.current` ఇప్పటికే 3, కాబట్టి `__next__` కు తదుపరి కాల్ వెంటనే `StopIteration` ను పెంచుతుంది. ఇది మా ఆబ్జెక్ట్ దాని స్వంత ఇటరేటర్‌గా ఉండటం వల్ల కలిగే పర్యవసానంగా ఉంది.
అధునాతన ఇటరేటర్ భావనలు మరియు వాస్తవ ప్రపంచ అనువర్తనాలు
సాధారణ కౌంటర్‌లు నేర్చుకోవడానికి గొప్ప మార్గం, కానీ ఇటరేటర్ ప్రోటోకాల్ యొక్క నిజమైన శక్తి మరింత సంక్లిష్టమైన, అనుకూల డేటా నిర్మాణాలకు వర్తింపజేసినప్పుడు ప్రకాశిస్తుంది.
ఇటరేబుల్ మరియు ఇటరేటర్‌ను కలపడంతో సమస్య
మా `CountUpTo` ఉదాహరణలో, తరగతి ఇటరేబుల్ మరియు ఇటరేటర్ రెండూ. ఇది సరళమైనది కానీ ఒక ప్రధాన లోపం ఉంది: ఫలిత ఇటరేటర్ క్షీణించగలదు. మీరు దానిపై లూప్ చేసిన తర్వాత, అది పూర్తవుతుంది.
కోడ్:
counter = CountUpTo(2)
print("First iteration:")
for num in counter: print(num) # Works fine
print("\nSecond iteration:")
for num in counter: print(num) # Prints nothing!
ఇది స్థితి (`self.current`) ఆబ్జెక్ట్‌లోనే నిల్వ చేయబడటం వలన జరుగుతుంది. మొదటి లూప్ తర్వాత, `self.current` 2, మరియు తదుపరి `__next__` కాల్‌లు `StopIteration` ను మాత్రమే పెంచుతాయి. ఈ ప్రవర్తన ప్రామాణిక పైథాన్ జాబితాకు భిన్నంగా ఉంటుంది, దీనిని మీరు అనేక సార్లు ఇటరేట్ చేయవచ్చు.
మరింత దృఢమైన నమూనా: ఇటరేబుల్‌ను ఇటరేటర్ నుండి వేరు చేయడం
పైథాన్ యొక్క అంతర్నిర్మిత కలెక్షన్‌ల వంటి పునర్వినియోగ ఇటరేబుల్‌లను సృష్టించడానికి, రెండు పాత్రలను వేరు చేయడం ఉత్తమ పద్ధతి. కంటైనర్ ఆబ్జెక్ట్ ఇటరేబుల్ అవుతుంది, మరియు దాని `__iter__` పద్ధతికి కాల్ చేసిన ప్రతిసారీ అది ఒక కొత్త, తాజా ఇటరేటర్ ఆబ్జెక్ట్‌ను ఉత్పత్తి చేస్తుంది.
మా ఉదాహరణను రెండు తరగతులుగా పునర్నిర్మిద్దాం: `Sentence` (ఇటరేబుల్) మరియు `SentenceIterator` (ఇటరేటర్).
కోడ్:
class SentenceIterator:
"""The iterator responsible for state and producing values."""
def __init__(self, words):
self.words = words
self.index = 0
def __next__(self):
try:
word = self.words[self.index]
except IndexError:
raise StopIteration()
self.index += 1
return word
def __iter__(self):
# An iterator must also be an iterable, returning itself.
return self
class Sentence:
"""The iterable container class."""
def __init__(self, text):
# The container holds the data.
self.words = text.split()
def __iter__(self):
# Each time __iter__ is called, it creates a NEW iterator object.
return SentenceIterator(self.words)
# How to use it
my_sentence = Sentence('This is a test')
print("First iteration:")
for word in my_sentence:
print(word)
print("\nSecond iteration:")
for word in my_sentence:
print(word)
ఇప్పుడు, ఇది ఒక జాబితా వలె ఖచ్చితంగా పనిచేస్తుంది! `for` లూప్ ప్రారంభమైన ప్రతిసారీ, అది `my_sentence.__iter__()` ను పిలుస్తుంది, ఇది దాని స్వంత స్థితి (`self.index = 0`) తో సరికొత్త `SentenceIterator` ఉదాహరణను సృష్టిస్తుంది. ఇది అదే `Sentence` ఆబ్జెక్ట్‌పై బహుళ, స్వతంత్ర ఇటరేషన్‌లను అనుమతిస్తుంది. ఈ నమూనా చాలా దృఢమైనది మరియు పైథాన్ యొక్క స్వంత కలెక్షన్‌లు ఎలా అమలు చేయబడ్డాయి.
ఉదాహరణ: అనంత ఇటరేటర్‌లు
ఇటరేటర్‌లు పరిమితంగా ఉండవలసిన అవసరం లేదు. అవి అనంతమైన డేటా క్రమాన్ని సూచించగలవు. ఇక్కడ వాటి లేజీ, ఒకేసారి స్వభావం చాలా పెద్ద ప్రయోజనం. ఫిబోనాచి సంఖ్యల యొక్క అనంతమైన క్రమం కోసం ఒక ఇటరేటర్‌ను సృష్టిద్దాం.
కోడ్:
class FibonacciIterator:
"""Generates an infinite sequence of Fibonacci numbers."""
def __init__(self):
self.a, self.b = 0, 1
def __iter__(self):
return self
def __next__(self):
result = self.a
self.a, self.b = self.b, self.a + self.b
return result
# How to use it - CAUTION: Infinite loop without a break!
fib_gen = FibonacciIterator()
for i, num in enumerate(fib_gen):
print(f"Fibonacci({i}): {num}")
if i >= 10: # We must provide a stopping condition
break
ఈ ఇటరేటర్ తనంతట తానుగా `StopIteration` ను ఎప్పుడూ పెంచదు. లూప్‌ను ముగించడానికి ఒక షరతును (`break` స్టేట్‌మెంట్ వంటిది) అందించడం కాలింగ్ కోడ్ యొక్క బాధ్యత. ఈ నమూనా డేటా స్ట్రీమింగ్, ఈవెంట్ లూప్‌లు మరియు సంఖ్యా అనుకరణలలో సాధారణం.
పైథాన్ ఎకోసిస్టమ్‌లో ఇటరేటర్ ప్రోటోకాల్
`__iter__` మరియు `__next__` లను అర్థం చేసుకోవడం పైథాన్‌లో వాటి ప్రభావాన్ని ప్రతిచోటా చూడటానికి మిమ్మల్ని అనుమతిస్తుంది. పైథాన్ యొక్క అనేక లక్షణాలను సజావుగా కలిసి పనిచేసేలా చేసే ఏకీకృత ప్రోటోకాల్ ఇది.
`for` లూప్‌లు *నిజంగా* ఎలా పనిచేస్తాయి
మేము దీని గురించి పరోక్షంగా చర్చించాము, కానీ దానిని స్పష్టం చేద్దాం. పైథాన్ ఈ పంక్తిని ఎదుర్కొన్నప్పుడు:
`for item in my_iterable:`
ఇది తెర వెనుక క్రింది దశలను నిర్వహిస్తుంది:
- ఇటరేటర్‌ను పొందడానికి `iter(my_iterable)` ను పిలుస్తుంది. ఇది, క్రమంగా, `my_iterable.__iter__()` ను పిలుస్తుంది. తిరిగి వచ్చిన ఆబ్జెక్ట్‌ను `iterator_obj` అని పిలుద్దాం.
- ఇది అనంతమైన `while True` లూప్‌లోకి ప్రవేశిస్తుంది.
- లూప్‌లోపల, ఇది `next(iterator_obj)` ను పిలుస్తుంది, ఇది క్రమంగా `iterator_obj.__next__()` ను పిలుస్తుంది.
- `__next__` ఒక విలువను తిరిగి ఇస్తే, అది `item` వేరియబుల్‌కు కేటాయించబడుతుంది మరియు `for` లూప్ బ్లాక్‌లోని కోడ్ అమలు చేయబడుతుంది.
- `__next__` ఒక `StopIteration` మినహాయింపును పెంచితే, `for` లూప్ ఈ మినహాయింపును పట్టుకుని దాని అంతర్గత `while` లూప్ నుండి బయటకు వస్తుంది. ఇటరేషన్ పూర్తవుతుంది.
కాంప్రెహెన్షన్‌లు మరియు జనరేటర్ ఎక్స్‌ప్రెషన్‌లు
జాబితా, సెట్ మరియు డిక్షనరీ కాంప్రెహెన్షన్‌లు అన్నీ ఇటరేటర్ ప్రోటోకాల్ ద్వారా శక్తిని పొందుతాయి. మీరు వ్రాసినప్పుడు:
`squares = [x * x for x in range(10)]`
పైథాన్ ప్రభావవంతంగా `range(10)` ఆబ్జెక్ట్‌పై ఇటరేషన్‌ను నిర్వహిస్తుంది, ప్రతి విలువను పొందుతుంది మరియు జాబితాను నిర్మించడానికి `x * x` ఎక్స్‌ప్రెషన్‌ను అమలు చేస్తుంది. లేజీ ఇటరేషన్ యొక్క మరింత ప్రత్యక్ష ఉపయోగం అయిన జనరేటర్ ఎక్స్‌ప్రెషన్‌లకు కూడా ఇది వర్తిస్తుంది:
`lazy_squares = (x * x for x in range(1000000))`
ఇది మెమరీలో మిలియన్-అంశాల జాబితాను సృష్టించదు. ఇది ఒక ఇటరేటర్‌ను (ప్రత్యేకంగా, ఒక జనరేటర్ ఆబ్జెక్ట్‌ను) సృష్టిస్తుంది, ఇది మీరు దానిపై ఇటరేట్ చేస్తున్నప్పుడు చతురస్రాలను ఒక్కొక్కటిగా లెక్కిస్తుంది.
జనరేటర్‌లు: ఇటరేటర్‌లను సృష్టించడానికి సరళమైన మార్గం
`__iter__` మరియు `__next__` లతో పూర్తి తరగతిని సృష్టించడం మీకు గరిష్ట నియంత్రణను ఇస్తుంది, అయితే సాధారణ సందర్భాలలో ఇది చాలా విస్తారంగా ఉంటుంది. పైథాన్ ఇటరేటర్‌లను సృష్టించడానికి చాలా సంక్షిప్త సింటాక్స్‌ను అందిస్తుంది: జనరేటర్‌లు.
ఒక జనరేటర్ అనేది `yield` కీవర్డ్‌ను ఉపయోగించే ఒక ఫంక్షన్. మీరు ఒక జనరేటర్ ఫంక్షన్‌ను పిలిచినప్పుడు, అది కోడ్‌ను అమలు చేయదు. బదులుగా, ఇది ఒక జనరేటర్ ఆబ్జెక్ట్‌ను తిరిగి ఇస్తుంది, ఇది పూర్తిగా అభివృద్ధి చెందిన ఇటరేటర్.
మా `CountUpTo` ఉదాహరణను జనరేటర్‌గా తిరిగి వ్రాద్దాం:
కోడ్:
def count_up_to_generator(max_num):
"""A generator function that yields numbers from 1 to max_num."""
print("Generator started...")
current = 1
while current <= max_num:
yield current # Pauses here and sends a value back
current += 1
print("Generator finished.")
# How to use it
counter_gen = count_up_to_generator(3)
for number in counter_gen:
print(f"For loop received: {number}")
అది ఎంత సరళంగా ఉందో చూడండి! `yield` కీవర్డ్ ఇక్కడ మాయాజాలం. `yield` ను ఎదుర్కొన్నప్పుడు, ఫంక్షన్ యొక్క స్థితి స్తంభింపజేయబడుతుంది, విలువ కాలర్‌కు పంపబడుతుంది మరియు ఫంక్షన్ పాజ్ అవుతుంది. జనరేటర్ ఆబ్జెక్ట్‌పై `__next__` మళ్ళీ కాల్ చేయబడినప్పుడు, ఫంక్షన్ అది ఆపివేసిన చోటు నుండే అమలును పునఃప్రారంభిస్తుంది, అది మరొక `yield` ను తాకే వరకు లేదా ఫంక్షన్ ముగిసే వరకు. ఫంక్షన్ పూర్తయినప్పుడు, `StopIteration` స్వయంచాలకంగా మీ కోసం పెంచబడుతుంది.
తెర వెనుక, పైథాన్ స్వయంచాలకంగా `__iter__` మరియు `__next__` పద్ధతులతో ఒక ఆబ్జెక్ట్‌ను సృష్టించింది. జనరేటర్‌లు తరచుగా మరింత ఆచరణాత్మక ఎంపిక అయినప్పటికీ, డీబగ్గింగ్, సంక్లిష్ట వ్యవస్థలను రూపొందించడం మరియు పైథాన్ యొక్క ప్రధాన మెకానిక్స్ ఎలా పనిచేస్తాయో అభినందించడానికి అంతర్లీన ప్రోటోకాల్‌ను అర్థం చేసుకోవడం చాలా అవసరం.
ఉత్తమ పద్ధతులు మరియు సాధారణ లోపాలు
ఇటరేటర్ ప్రోటోకాల్‌ను అమలు చేస్తున్నప్పుడు, సాధారణ లోపాలను నివారించడానికి ఈ మార్గదర్శకాలను గుర్తుంచుకోండి.
ఉత్తమ పద్ధతులు
- ఇటరేబుల్ మరియు ఇటరేటర్‌ను వేరు చేయండి: బహుళ ట్రావర్సల్‌లకు మద్దతు ఇవ్వాల్సిన ఏదైనా కంటైనర్ ఆబ్జెక్ట్ కోసం, ఎల్లప్పుడూ ఇటరేటర్‌ను ప్రత్యేక తరగతిలో అమలు చేయండి. కంటైనర్ యొక్క `__iter__` పద్ధతి ప్రతిసారీ ఇటరేటర్ తరగతి యొక్క కొత్త ఉదాహరణను తిరిగి ఇవ్వాలి.
- ఎల్లప్పుడూ `StopIteration` ను పెంచండి: `__next__` పద్ధతి ముగింపును సూచించడానికి `StopIteration` ను విశ్వసనీయంగా పెంచాలి. దీనిని మర్చిపోవడం అనంతమైన లూప్‌లకు దారితీస్తుంది.
- ఇటరేటర్‌లు ఇటరేబుల్‌గా ఉండాలి: ఒక ఇటరేటర్ యొక్క `__iter__` పద్ధతి ఎల్లప్పుడూ `self` ను తిరిగి ఇవ్వాలి. ఇది ఇటరేటర్‌ను ఇటరేబుల్ ఆశించిన చోట ఎక్కడైనా ఉపయోగించడానికి అనుమతిస్తుంది.
- సరళత కోసం జనరేటర్‌లను ఇష్టపడండి: మీ ఇటరేటర్ లాజిక్ సూటిగా ఉండి, ఒకే ఫంక్షన్‌గా వ్యక్తీకరించబడగలిగితే, జనరేటర్ దాదాపు ఎల్లప్పుడూ క్లీనర్‌గా మరియు మరింత రీడబుల్‌గా ఉంటుంది. ఇటరేటర్ ఆబ్జెక్ట్‌తో మరింత సంక్లిష్టమైన స్థితిని లేదా పద్ధతులను అనుబంధించాల్సిన అవసరం వచ్చినప్పుడు పూర్తి ఇటరేటర్ తరగతిని ఉపయోగించండి.
సాధారణ లోపాలు
- ఎగ్జాస్టబుల్ ఇటరేటర్ సమస్య: చర్చించినట్లుగా, ఒక ఆబ్జెక్ట్ దాని స్వంత ఇటరేటర్‌గా ఉన్నప్పుడు, అది ఒకసారి మాత్రమే ఉపయోగించబడుతుంది. మీరు అనేక సార్లు ఇటరేట్ చేయాల్సిన అవసరం ఉంటే, మీరు కొత్త ఉదాహరణను సృష్టించాలి లేదా వేరు చేయబడిన ఇటరేబుల్/ఇటరేటర్ నమూనాను ఉపయోగించాలి.
- స్థితిని మర్చిపోవడం: `__next__` పద్ధతి ఇటరేటర్ యొక్క అంతర్గత స్థితిని సవరించాలి (ఉదాహరణకు, ఒక సూచికను పెంచడం లేదా ఒక పాయింటర్‌ను ముందుకు తీసుకెళ్లడం). స్థితి నవీకరించబడకపోతే, `__next__` అదే విలువను పదేపదే తిరిగి ఇస్తుంది, ఇది అనంతమైన లూప్‌కు దారితీయవచ్చు.
- ఇటరేట్ చేస్తున్నప్పుడు కలెక్షన్‌ను సవరించడం: ఇటరేట్ చేస్తున్నప్పుడు ఒక కలెక్షన్‌ను సవరించడం (ఉదాహరణకు, దానిపై ఇటరేట్ చేస్తున్న `for` లూప్ లోపల ఒక జాబితా నుండి అంశాలను తీసివేయడం) అంచనా వేయలేని ప్రవర్తనకు దారితీయవచ్చు, అంటే అంశాలను దాటవేయడం లేదా ఊహించని లోపాలను పెంచడం వంటివి. మీరు అసలు దానిని సవరించాల్సిన అవసరం ఉంటే కలెక్షన్ యొక్క కాపీపై ఇటరేట్ చేయడం సాధారణంగా సురక్షితం.
ముగింపు
ఇటరేటర్ ప్రోటోకాల్, దాని సాధారణ `__iter__` మరియు `__next__` పద్ధతులతో, పైథాన్‌లో ఇటరేషన్ యొక్క పునాది. ఇది భాష యొక్క డిజైన్ తత్వశాస్త్రానికి నిదర్శనం: శక్తివంతమైన మరియు సంక్లిష్ట ప్రవర్తనలను ప్రారంభించే సాధారణ, స్థిరమైన ఇంటర్‌ఫేస్‌లకు ప్రాధాన్యత ఇవ్వడం. సీక్వెన్షియల్ డేటా యాక్సెస్ కోసం సార్వత్రిక ఒప్పందాన్ని అందించడం ద్వారా, ప్రోటోకాల్ `for` లూప్‌లు, కాంప్రెహెన్షన్‌లు మరియు అనేక ఇతర సాధనాలను దాని భాషను మాట్లాడటానికి ఎంచుకునే ఏదైనా ఆబ్జెక్ట్‌తో సజావుగా పనిచేయడానికి అనుమతిస్తుంది.
ఈ ప్రోటోకాల్‌ను సాధించడం ద్వారా, మీరు పైథాన్ ఎకోసిస్టమ్‌లో మొదటి-స్థాయి పౌరులైన మీ స్వంత సీక్వెన్స్-వంటి వస్తువులను సృష్టించే సామర్థ్యాన్ని అన్‌లాక్ చేసారు. మీరు ఇప్పుడు డేటాను లేజీగా ప్రాసెస్ చేయడం ద్వారా మరింత మెమరీ-సమర్థవంతంగా, ప్రామాణిక పైథాన్ సింటాక్స్‌తో శుభ్రంగా ఏకీకృతం చేయడం ద్వారా మరింత సహజంగా మరియు అంతిమంగా మరింత శక్తివంతంగా ఉండే తరగతులను వ్రాయవచ్చు. మీరు తదుపరిసారి `for` లూప్‌ను వ్రాసినప్పుడు, ఉపరితలం క్రింద జరుగుతున్న `__iter__` మరియు `__next__` యొక్క సొగసైన నృత్యానికి ఒక క్షణం కేటాయించండి.